<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Class template unordered_set</title>
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../intrusive/reference.html#doxygen.unordered__set_8hpp" title="Header &lt;boost/intrusive/unordered_set.hpp&gt;">
<link rel="prev" href="classboost_1_1intrusive_1_1unordered__multiset.html" title="Class template unordered_multiset">
<link rel="next" href="structboost_1_1intrusive_1_1make__unordered__set__base__hook.html" title="Struct template make_unordered_set_base_hook">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
<td align="center"><a href="../../../index.html">Home</a></td>
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="classboost_1_1intrusive_1_1unordered__multiset.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../intrusive/reference.html#doxygen.unordered__set_8hpp"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="structboost_1_1intrusive_1_1make__unordered__set__base__hook.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="refentry">
<a name="doxygen.classboost_1_1intrusive_1_1unordered__set"></a><div class="titlepage"></div>
<div class="refnamediv">
<h2><span class="refentrytitle">Class template unordered_set</span></h2>
<p>boost::intrusive::unordered_set</p>
</div>
<h2 class="refsynopsisdiv-title">Synopsis</h2>
<div class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="../intrusive/reference.html#doxygen.unordered__set_8hpp" title="Header &lt;boost/intrusive/unordered_set.hpp&gt;">boost/intrusive/unordered_set.hpp</a>&gt;

</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">class</span> <span class="special">...</span> Options<span class="special">&gt;</span> 
<span class="keyword">class</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="comment">// types</span>
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">value_type</span>           <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a9e8af8340a055f500fda12b5826c5e2c"></a><span class="identifier">value_type</span><span class="special">;</span>          
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">key_type</span>             <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af614bc165907e0f9fe16823b1b211e72"></a><span class="identifier">key_type</span><span class="special">;</span>            
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">key_of_value</span>         <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1aa759f684fff8a61615cb6a4bb3f2111a"></a><span class="identifier">key_of_value</span><span class="special">;</span>        
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">value_traits</span>         <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ab25fd1f211c3f4e3dd5fc8fec7367dff"></a><span class="identifier">value_traits</span><span class="special">;</span>        
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">bucket_traits</span>        <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1aaa036b35a72ec74665ace168f8727d14"></a><span class="identifier">bucket_traits</span><span class="special">;</span>       
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">pointer</span>              <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a452321aa56d54bc8ce229470684ce50c"></a><span class="identifier">pointer</span><span class="special">;</span>             
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">const_pointer</span>        <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ae4ec4f0b6d5a881dcc8b2a6d2ef02ffd"></a><span class="identifier">const_pointer</span><span class="special">;</span>       
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">reference</span>            <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1abb90d0ce0dacb6ca3c86ef5d4d365f49"></a><span class="identifier">reference</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">const_reference</span>      <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a12c6007d4fffb6f20e963b3a9b9b19be"></a><span class="identifier">const_reference</span><span class="special">;</span>     
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">difference_type</span>      <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a2915ebf2ae034d86bb901edc7e78aefa"></a><span class="identifier">difference_type</span><span class="special">;</span>     
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">size_type</span>            <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a24c68aa4660bc9c52ee288558325d7df"></a><span class="identifier">size_type</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">key_equal</span>            <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ae88b522ac8f6b979fadf341754da31ab"></a><span class="identifier">key_equal</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">hasher</span>               <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a653588a22f6fc3a83233549388a63fff"></a><span class="identifier">hasher</span><span class="special">;</span>              
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">bucket_type</span>          <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a10b0246f993a249b9de6b8a5c3ed504a"></a><span class="identifier">bucket_type</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">bucket_ptr</span>           <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a2488a70f2dcf346126e2c630c534bfbe"></a><span class="identifier">bucket_ptr</span><span class="special">;</span>          
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">iterator</span>             <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a739f11ec99fe19a1628f02890ef31511"></a><span class="identifier">iterator</span><span class="special">;</span>            
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">const_iterator</span>       <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1aa3c0e0318db2726718547a1cf7ef0dc1"></a><span class="identifier">const_iterator</span><span class="special">;</span>      
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">insert_commit_data</span>   <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a0b95f3290f994822e9e3721c677c5c80"></a><span class="identifier">insert_commit_data</span><span class="special">;</span>  
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">local_iterator</span>       <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a5f0790486b87529590b46d4ca34729d8"></a><span class="identifier">local_iterator</span><span class="special">;</span>      
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">const_local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a27db31ee75de5d9eac5458306fd98a83"></a><span class="identifier">const_local_iterator</span><span class="special">;</span>
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">node_traits</span>          <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ae1dce119ae7ee33969cf6691c376928d"></a><span class="identifier">node_traits</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">node</span>                 <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a1f5f86c06b5910545f08e192f7fb83df"></a><span class="identifier">node</span><span class="special">;</span>                
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">node_ptr</span>             <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a996c8606620e6d085cad101c49e5402c"></a><span class="identifier">node_ptr</span><span class="special">;</span>            
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span><span class="special">::</span><span class="identifier">const_node_ptr</span>       <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af280cf18f4f41e2d34c84e4157290ce9"></a><span class="identifier">const_node_ptr</span><span class="special">;</span>      

  <span class="comment">// <a class="link" href="boost_interprocess_header_reference/classboost_1_1interprocess_1_1windows__shared__memory.html#id106-bb">public member functions</a></span>
  <span class="keyword">explicit</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a3b1b7b19a25e808459a80196e86952c0"><span class="identifier">unordered_set</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">hasher</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">hasher</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                         <span class="keyword">const</span> <span class="identifier">key_equal</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">key_equal</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                         <span class="keyword">const</span> <span class="identifier">value_traits</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">value_traits</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac949e112f962b99faa5c8730218022ef"><span class="identifier">unordered_set</span></a><span class="special">(</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span><span class="special">,</span> 
                  <span class="keyword">const</span> <span class="identifier">hasher</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">hasher</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">key_equal</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">key_equal</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                  <span class="keyword">const</span> <span class="identifier">value_traits</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">value_traits</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a3d88b53b9eb4bc183b894dc84a6eedd5"><span class="identifier">unordered_set</span></a><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1accfb0d50923892e26dfa51b596d66afb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a0dc61b213ba866ee37509551aca7fae5"><span class="special">~</span><span class="identifier">unordered_set</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a64aac9167b81e1c6f88872f06215ba1d"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a7c1ce50320e51e8b6e7cdb86bfab49f1"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a32c5aad7dac6eaedef02a01635ad45c2"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac23489c158c1ea61f72f4e5e10babd05"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a5d1b5c132f34d8722cbe584d5b766b92"><span class="identifier">cend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">hasher</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a84d9c835d4b8eca7d084456caf2db2e6"><span class="identifier">hash_function</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">key_equal</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac324001742a7f4f4e52927c6af917366"><span class="identifier">key_eq</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a5f7d7c3a0992ae8f68ec368fbc42e114"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a09c5b6164cc233275e01eab325f32f2a"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Cloner<span class="special">,</span> <span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac6e8053358fba482407bd88cff8da85b"><span class="identifier">clone_from</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Cloner</span><span class="special">,</span> <span class="identifier">Disposer</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Cloner<span class="special">,</span> <span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac595e05924da3977b92ce70004068c13"><span class="identifier">clone_from</span></a><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;&amp;</span><span class="special">,</span> <span class="identifier">Cloner</span><span class="special">,</span> <span class="identifier">Disposer</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a1be30a059cb9b4e02e14ad61a265aee9"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">reference</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1af1364cc124deb7847ce6aadc8e10dccb"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> 
  <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a3da56d679524816036ee6f9820ff9745"><span class="identifier">insert_check</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a4ef55a4518d9720bd953c7bf80c04dd5"><span class="identifier">insert_check</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">,</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a311a6a112648da2af705025d62af04d2"><span class="identifier">insert_commit</span></a><span class="special">(</span><span class="identifier">reference</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a93b4b5af5b70dbb23bcec5fcf86cfa1f"><span class="identifier">insert_fast_commit</span></a><span class="special">(</span><span class="identifier">reference</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1adb2aac843ac249ee4a321a002d6e4421"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a03244646d5355b5de7ef686ee3e8ef6f"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ab58a1726a2c6f2698377ca33bd5247df"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a0cd2867935e37b3d423c607127357417"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a7bac74b28e399a035e3b110f45605ae2"><span class="identifier">erase_and_dispose</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Disposer</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a18f52ee26e23a2bbd7d21440e1e4a65d"><span class="identifier">erase_and_dispose</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Disposer</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
    <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a04ab943c5967158f905383a880a0e9fd"><span class="identifier">erase_and_dispose</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Disposer</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">,</span> 
           <span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
    <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a978d41e1587b290b60de7511c2936703"><span class="identifier">erase_and_dispose</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">,</span> 
                                <span class="identifier">Disposer</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a859c25b3bbabe770cb867b455fe7590a"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1adfdedb5282d77776b66a5cbad1d11d6c"><span class="identifier">clear_and_dispose</span></a><span class="special">(</span><span class="identifier">Disposer</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a280eb774c3e14f8ba3fde44483f0a92f"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a0a23e7b08708b98482e608fba662fd1b"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a556c8e135ad7343db0481c18b6337850"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a101006012828615a05ce6ef7c6d125e3"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1af9ed3738718112e71247b9d9c2ad66cd"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1afa81409b2b10e9e975e2bdb9303a06bb"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1af78e5b3dbb4a968a59e3c2c61c755bfb"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1af3582b96bbbb007d4044df90e86a2727"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
  <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1af864c28aafb3122779aa1e291791cb82"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a6c00614bd3ef78247dfb1975d4b7a191"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">,</span> <span class="identifier">KeyEqual</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a34b2c5bb332fc01aaa52656d0753f932"><span class="identifier">iterator_to</span></a><span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac25be409d71df349ee58594519513062"><span class="identifier">iterator_to</span></a><span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a4130c0956d71778f78644c0655fe416c"><span class="identifier">local_iterator_to</span></a><span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1aa47a4e6e5bb4d448a51cb845d8170142"><span class="identifier">local_iterator_to</span></a><span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2"><span class="identifier">bucket_count</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a5d14f3d85df0aa9b06d943545393702f"><span class="identifier">bucket_size</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a0e4385e4570b5dff4cdbede21b0a42ce"><span class="identifier">bucket</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">&gt;</span> 
    <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a5fd970e31fed491f319d8b7020c52d83"><span class="identifier">bucket</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">KeyHasher</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">bucket_ptr</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a1873fe24ccb8dd831111ac11594fa885"><span class="identifier">bucket_pointer</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1acc350a5919b385994aa6784b773df166"><span class="identifier">begin</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ac8967beebeabb7dd93ecc27a7c63aad7"><span class="identifier">begin</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a855992523c55e74cd5691a377601bc5c"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a649a071731f6c9ee2dd385532edeef45"><span class="identifier">end</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ab90bc870d13993a9ac474c8d9ff9aa41"><span class="identifier">end</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1afbea5b1c32cc39af657b9f96426a49c8"><span class="identifier">cend</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ab3004e31b8d79e51feea2453733f800e"><span class="identifier">rehash</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a3eb11ce917ff0940c5449ad498361dee"><span class="identifier">full_rehash</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1afc16c65b7eb9f1f0f11a146aeb2dcbe9"><span class="identifier">incremental_rehash</span></a><span class="special">(</span><span class="keyword">bool</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ae1470c48f8e5ce4f877c38e5485c96ac"><span class="identifier">incremental_rehash</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a41482f21f938c099a358c0ae72afa114"><span class="identifier">split_count</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

  <span class="comment">// <a class="link" href="boost_interprocess_header_reference/classboost_1_1interprocess_1_1xsi__key.html#id107-bb">public static functions</a></span>
  <span class="keyword">static</span> <span class="identifier">local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1af7f23fe913415154b1b07314705fa1d2"><span class="identifier">s_local_iterator_to</span></a><span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">static</span> <span class="identifier">const_local_iterator</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1ad283c478c8f3952010e1a051ac137920"><span class="identifier">s_local_iterator_to</span></a><span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">static</span> <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a7709f06fa88c66b613d4917c296b7a85"><span class="identifier">suggested_upper_bucket_count</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">static</span> <span class="identifier">size_type</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a5480cfcd11b6b40ac8aae19a5c7bd991"><span class="identifier">suggested_lower_bucket_count</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div>
<div class="refsect1">
<a name="id-1.3.17.42.44.6.4"></a><h2>Description</h2>
<p>The class template <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> is an intrusive container, that mimics most of the interface of std::tr1::unordered_set as described in the C++ TR1.</p>
<p><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> is a semi-intrusive container: each object to be stored in the container must contain a proper hook, but the container also needs additional auxiliary memory to work: <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> needs a pointer to an array of type <code class="computeroutput">bucket_type</code> to be passed in the constructor. This bucket array must have at least the same lifetime as the container. This makes the use of <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> more complicated than purely intrusive containers. <code class="computeroutput">bucket_type</code> is default-constructible, copyable and assignable</p>
<p>The template parameter <code class="computeroutput">T</code> is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.</p>
<p>The container supports the following options: <code class="computeroutput">base_hook&lt;&gt;/member_hook&lt;&gt;/value_traits&lt;&gt;</code>, <code class="computeroutput">constant_time_size&lt;&gt;</code>, <code class="computeroutput">size_type&lt;&gt;</code>, <code class="computeroutput">hash&lt;&gt;</code> and <code class="computeroutput">equal&lt;&gt;</code> <code class="computeroutput">bucket_traits&lt;&gt;</code>, <code class="computeroutput">power_2_buckets&lt;&gt;</code> and <code class="computeroutput">cache_begin&lt;&gt;</code>.</p>
<p><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> only provides forward iterators but it provides 4 iterator types: iterator and const_iterator to navigate through the whole container and local_iterator and const_local_iterator to navigate through the values stored in a single bucket. Local iterators are faster and smaller.</p>
<p>It's not recommended to use non constant-time size unordered_sets because several key functions, like "empty()", become non-constant time functions. Non constant-time size unordered_sets are mainly provided to support auto-unlink hooks.</p>
<p><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>, unlike std::unordered_set, does not make automatic rehashings nor offers functions related to a load factor. Rehashing can be explicitly requested and the user must provide a new bucket array that will be used from that moment.</p>
<p>Since no automatic rehashing is done, iterators are never invalidated when inserting or erasing elements. Iterators are only invalidated when rehasing. </p>
<div class="refsect2">
<a name="id-1.3.17.42.44.6.4.10"></a><h3>
<a name="id106-bb"></a><code class="computeroutput">unordered_set</code> public member functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem"><pre class="literallayout"><span class="keyword">explicit</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a3b1b7b19a25e808459a80196e86952c0"></a><span class="identifier">unordered_set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span> b_traits<span class="special">,</span> 
                       <span class="keyword">const</span> <span class="identifier">hasher</span> <span class="special">&amp;</span> hash_func <span class="special">=</span> <span class="identifier">hasher</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                       <span class="keyword">const</span> <span class="identifier">key_equal</span> <span class="special">&amp;</span> equal_func <span class="special">=</span> <span class="identifier">key_equal</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                       <span class="keyword">const</span> <span class="identifier">value_traits</span> <span class="special">&amp;</span> v_traits <span class="special">=</span> <span class="identifier">value_traits</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> 
  <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac949e112f962b99faa5c8730218022ef"></a><span class="identifier">unordered_set</span><span class="special">(</span><span class="identifier">Iterator</span> b<span class="special">,</span> <span class="identifier">Iterator</span> e<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span> b_traits<span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">hasher</span> <span class="special">&amp;</span> hash_func <span class="special">=</span> <span class="identifier">hasher</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">key_equal</span> <span class="special">&amp;</span> equal_func <span class="special">=</span> <span class="identifier">key_equal</span><span class="special">(</span><span class="special">)</span><span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">value_traits</span> <span class="special">&amp;</span> v_traits <span class="special">=</span> <span class="identifier">value_traits</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a3d88b53b9eb4bc183b894dc84a6eedd5"></a><span class="identifier">unordered_set</span><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs a container moving resources from another container. Internal value traits, bucket traits, hasher and comparison are move constructed and nodes belonging to x are linked to *this.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: If value_traits::node_traits::node's move constructor throws (this does not happen with predefined Boost.Intrusive hooks) or the move constructor of value traits, bucket traits, hasher or comparison throws.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1accfb0d50923892e26dfa51b596d66afb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to swap.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a0dc61b213ba866ee37509551aca7fae5"></a><span class="special">~</span><span class="identifier">unordered_set</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Detaches all elements from this. The objects in the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> are not deleted (i.e. no destructors are called).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>, if it's a safe-mode or auto-unlink value. Otherwise constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a64aac9167b81e1c6f88872f06215ba1d"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator pointing to the beginning of the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time. Worst case (empty <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>): O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2">bucket_count()</a>)</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a7c1ce50320e51e8b6e7cdb86bfab49f1"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator pointing to the beginning of the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time. Worst case (empty <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>): O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2">bucket_count()</a>)</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a32c5aad7dac6eaedef02a01635ad45c2"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator pointing to the beginning of the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time. Worst case (empty <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>): O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2">bucket_count()</a>)</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator pointing to the end of the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac23489c158c1ea61f72f4e5e10babd05"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator pointing to the end of the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a5d1b5c132f34d8722cbe584d5b766b92"></a><span class="identifier">cend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator pointing to the end of the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">hasher</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a84d9c835d4b8eca7d084456caf2db2e6"></a><span class="identifier">hash_function</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the hasher object used by the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: If hasher copy-constructor throws.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">key_equal</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac324001742a7f4f4e52927c6af917366"></a><span class="identifier">key_eq</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the key_equal object used by the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: If key_equal copy-constructor throws.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a5f7d7c3a0992ae8f68ec368fbc42e114"></a><span class="identifier">empty</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if the container is empty.</p>
<p><span class="bold"><strong>Complexity</strong></span>: if constant-time size and <a class="link" href="structboost_1_1intrusive_1_1cache__begin.html" title="Struct template cache_begin">cache_begin</a> options are disabled, average constant time (worst case, with <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a5f7d7c3a0992ae8f68ec368fbc42e114">empty()</a> == true: O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2">bucket_count()</a>). Otherwise constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de"></a><span class="identifier">size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the number of elements stored in the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to elements contained in *this if <a class="link" href="structboost_1_1intrusive_1_1constant__time__size.html" title="Struct template constant_time_size">constant_time_size</a> is false. Constant-time otherwise.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a09c5b6164cc233275e01eab325f32f2a"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;</span> other<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: buckets must not be being used by any other resource.</p>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a>, storing a reference to the bucket array and copies of the key_hasher and equal_func functors.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: If value_traits::node_traits::node constructor throws (this does not happen with predefined Boost.Intrusive hooks) or the copy constructor or invocation of hash_func or equal_func throws.</p>
<p><span class="bold"><strong>Notes</strong></span>: buckets array must be disposed only after *this is disposed.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Cloner<span class="special">,</span> <span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac6e8053358fba482407bd88cff8da85b"></a><span class="identifier">clone_from</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;</span> src<span class="special">,</span> <span class="identifier">Cloner</span> cloner<span class="special">,</span> <span class="identifier">Disposer</span> disposer<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: Disposer::operator()(pointer) shouldn't throw Cloner should yield to nodes that compare equal and produce the same hash than the original node.</p>
<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements from *this calling Disposer::operator()(pointer), clones all the elements from src calling Cloner::operator()(const_reference ) and inserts them on *this. The hash function and the equality predicate are copied from the source.</p>
<p>If <a class="link" href="structboost_1_1intrusive_1_1store__hash.html" title="Struct template store_hash">store_hash</a> option is true, this method does not use the hash function.</p>
<p>If any operation throws, all cloned elements are unlinked and disposed calling Disposer::operator()(pointer).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to erased plus inserted elements.</p>
<p><span class="bold"><strong>Throws</strong></span>: If cloner or hasher throw or hash or equality predicate copying throws. Basic guarantee.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Cloner<span class="special">,</span> <span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac595e05924da3977b92ce70004068c13"></a><span class="identifier">clone_from</span><span class="special">(</span><a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> <span class="special">&amp;&amp;</span> src<span class="special">,</span> <span class="identifier">Cloner</span> cloner<span class="special">,</span> <span class="identifier">Disposer</span> disposer<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: Disposer::operator()(pointer) shouldn't throw Cloner should yield to nodes that compare equal and produce the same hash than the original node.</p>
<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements from *this calling Disposer::operator()(pointer), clones all the elements from src calling Cloner::operator()(reference) and inserts them on *this. The hash function and the equality predicate are copied from the source.</p>
<p>If <a class="link" href="structboost_1_1intrusive_1_1store__hash.html" title="Struct template store_hash">store_hash</a> option is true, this method does not use the hash function.</p>
<p>If any operation throws, all cloned elements are unlinked and disposed calling Disposer::operator()(pointer).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to erased plus inserted elements.</p>
<p><span class="bold"><strong>Throws</strong></span>: If cloner or hasher throw or hash or equality predicate copying throws. Basic guarantee.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a1be30a059cb9b4e02e14ad61a265aee9"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">reference</span> value<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Iterator<span class="special">&gt;</span> <span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af1364cc124deb7847ce6aadc8e10dccb"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">Iterator</span> b<span class="special">,</span> <span class="identifier">Iterator</span> e<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: Dereferencing iterator must yield an lvalue of type value_type.</p>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to this-&gt;insert_unique(t) for each element in [b, e).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(N), where N is distance(b, e). Worst case O(N*this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If the internal hasher or the equality functor throws. Basic guarantee.</p>
<p><span class="bold"><strong>Note</strong></span>: Does not affect the validity of iterators and references. No copy-constructors are called.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> 
<a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a3da56d679524816036ee6f9820ff9745"></a><span class="identifier">insert_check</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span> commit_data<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> 
  <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a4ef55a4518d9720bd953c7bf80c04dd5"></a><span class="identifier">insert_check</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> 
               <span class="identifier">KeyEqual</span> key_value_equal<span class="special">,</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span> commit_data<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a311a6a112648da2af705025d62af04d2"></a><span class="identifier">insert_commit</span><span class="special">(</span><span class="identifier">reference</span> value<span class="special">,</span> 
                       <span class="keyword">const</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span> commit_data<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: value must be an lvalue of type value_type. commit_data must have been obtained from a previous call to "insert_check". No objects should have been inserted or erased from the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> between the "insert_check" that filled "commit_data" and the call to "insert_commit".</p>
<p><span class="bold"><strong>Effects</strong></span>: Inserts the value in the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> using the information obtained from the "commit_data" that a previous "insert_check" filled.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator to the newly inserted object.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant time.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Notes</strong></span>: This function has only sense if a "insert_check" has been previously executed to fill "commit_data". No value should be inserted or erased between the "insert_check" and "insert_commit" calls.</p>
<p>After a successful rehashing insert_commit_data remains valid.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a93b4b5af5b70dbb23bcec5fcf86cfa1f"></a><span class="identifier">insert_fast_commit</span><span class="special">(</span><span class="identifier">reference</span> value<span class="special">,</span> 
                            <span class="keyword">const</span> <span class="identifier">insert_commit_data</span> <span class="special">&amp;</span> commit_data<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: value must be an lvalue of type value_type. commit_data must have been obtained from a previous call to "insert_check". No objects should have been inserted or erased from the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> between the "insert_check" that filled "commit_data" and the call to "insert_commit".</p>
<p>No rehashing shall be performed between <code class="computeroutput">insert_check</code> and <code class="computeroutput">insert_fast_commit</code>.</p>
<p><span class="bold"><strong>Effects</strong></span>: Inserts the value in the <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html" title="Class template unordered_set">unordered_set</a> using the information obtained from the "commit_data" that a previous "insert_check" filled.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator to the newly inserted object.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant time.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Notes</strong></span>: This function has only sense if a "insert_check" has been previously executed to fill "commit_data". No value should be inserted or erased between the "insert_check" and "insert_commit" calls.</p>
<p>Since this commit operation does not support rehashing between the check and the commit, it's faster than <code class="computeroutput">insert_commit</code>.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1adb2aac843ac249ee4a321a002d6e4421"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> i<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a03244646d5355b5de7ef686ee3e8ef6f"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> b<span class="special">,</span> <span class="identifier">const_iterator</span> e<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ab58a1726a2c6f2698377ca33bd5247df"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a0cd2867935e37b3d423c607127357417"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> 
                  <span class="identifier">KeyEqual</span> equal_func<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p>"equal_func" must be a equality function that induces the same equality as key_equal. The difference is that "equal_func" compares an arbitrary key with the contained values.</p>
<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements that have the same hash and compare equal with the given key.</p>
<p><span class="bold"><strong>Returns</strong></span>: The number of erased elements.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(this-&gt;count(value)). Worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func or equal_func throw. Basic guarantee.</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a7bac74b28e399a035e3b110f45605ae2"></a><span class="identifier">erase_and_dispose</span><span class="special">(</span><span class="identifier">const_iterator</span> i<span class="special">,</span> <span class="identifier">Disposer</span> disposer<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a18f52ee26e23a2bbd7d21440e1e4a65d"></a><span class="identifier">erase_and_dispose</span><span class="special">(</span><span class="identifier">const_iterator</span> b<span class="special">,</span> <span class="identifier">const_iterator</span> e<span class="special">,</span> 
                         <span class="identifier">Disposer</span> disposer<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
  <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a04ab943c5967158f905383a880a0e9fd"></a><span class="identifier">erase_and_dispose</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">Disposer</span> disposer<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">,</span> 
         <span class="keyword">typename</span> Disposer<span class="special">&gt;</span> 
  <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a978d41e1587b290b60de7511c2936703"></a><span class="identifier">erase_and_dispose</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> 
                              <span class="identifier">KeyEqual</span> equal_func<span class="special">,</span> <span class="identifier">Disposer</span> disposer<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: Disposer::operator()(pointer) shouldn't throw.</p>
<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements with the given key. according to the comparison functor "equal_func". Disposer::operator()(pointer) is called for the removed elements.</p>
<p><span class="bold"><strong>Returns</strong></span>: The number of erased elements.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(this-&gt;count(value)). Worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func or equal_func throw. Basic guarantee.</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates the iterators to the erased elements.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a859c25b3bbabe770cb867b455fe7590a"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Erases all of the elements.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements on the container. if it's a safe-mode or auto-unlink value_type. Constant time otherwise.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Disposer<span class="special">&gt;</span> <span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1adfdedb5282d77776b66a5cbad1d11d6c"></a><span class="identifier">clear_and_dispose</span><span class="special">(</span><span class="identifier">Disposer</span> disposer<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: Disposer::operator()(pointer) shouldn't throw.</p>
<p><span class="bold"><strong>Effects</strong></span>: Erases all of the elements.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements on the container. Disposer::operator()(pointer) is called for the removed elements.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a280eb774c3e14f8ba3fde44483f0a92f"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a0a23e7b08708b98482e608fba662fd1b"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> 
                  <span class="identifier">KeyEqual</span> equal_func<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p>"equal_func" must be a equality function that induces the same equality as key_equal. The difference is that "equal_func" compares an arbitrary key with the contained values.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns the number of contained elements with the given key</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(1), worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func or equal throw.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a556c8e135ad7343db0481c18b6337850"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a101006012828615a05ce6ef7c6d125e3"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> <span class="identifier">KeyEqual</span> equal_func<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p>"equal_func" must be a equality function that induces the same equality as key_equal. The difference is that "equal_func" compares an arbitrary key with the contained values.</p>
<p><span class="bold"><strong>Effects</strong></span>: Finds an iterator to the first element whose key is "key" according to the given hash and equality functor or <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356">end()</a> if that element does not exist.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(1), worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func or equal_func throw.</p>
<p><span class="bold"><strong>Note</strong></span>: This function is used when constructing a value_type is expensive and the value_type can be compared with a cheaper key type. Usually this key is part of the value_type.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af9ed3738718112e71247b9d9c2ad66cd"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">const_iterator</span> 
  <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1afa81409b2b10e9e975e2bdb9303a06bb"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> <span class="identifier">KeyEqual</span> equal_func<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p>"equal_func" must be a equality function that induces the same equality as key_equal. The difference is that "equal_func" compares an arbitrary key with the contained values.</p>
<p><span class="bold"><strong>Effects</strong></span>: Finds an iterator to the first element whose key is "key" according to the given hasher and equality functor or <a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356">end()</a> if that element does not exist.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(1), worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func or equal_func throw.</p>
<p><span class="bold"><strong>Note</strong></span>: This function is used when constructing a value_type is expensive and the value_type can be compared with a cheaper key type. Usually this key is part of the value_type.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af78e5b3dbb4a968a59e3c2c61c755bfb"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> 
  <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af3582b96bbbb007d4044df90e86a2727"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> <span class="identifier">KeyEqual</span> equal_func<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p>"equal_func" must be a equality function that induces the same equality as key_equal. The difference is that "equal_func" compares an arbitrary key with the contained values.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns a range containing all elements with equivalent keys. Returns std::make_pair(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356">end()</a>, this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356">end()</a>) if no such elements exist.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(this-&gt;count(key, hash_func, equal_func)). Worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func or the equal_func throw.</p>
<p><span class="bold"><strong>Note</strong></span>: This function is used when constructing a value_type is expensive and the value_type can be compared with a cheaper key type. Usually this key is part of the value_type.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
<a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af864c28aafb3122779aa1e291791cb82"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> key<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">,</span> <span class="keyword">typename</span> KeyEqual<span class="special">&gt;</span> 
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
  <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a6c00614bd3ef78247dfb1975d4b7a191"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> key<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">,</span> <span class="identifier">KeyEqual</span> equal_func<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p>"equal_func" must be a equality function that induces the same equality as key_equal. The difference is that "equal_func" compares an arbitrary key with the contained values.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns a range containing all elements with equivalent keys. Returns std::make_pair(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356">end()</a>, this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1abcad758b2ac9547d1b31c6e9cd83b356">end()</a>) if no such elements exist.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case O(this-&gt;count(key, hash_func, equal_func)). Worst case O(this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>).</p>
<p><span class="bold"><strong>Throws</strong></span>: If the hasher or equal_func throw.</p>
<p><span class="bold"><strong>Note</strong></span>: This function is used when constructing a value_type is expensive and the value_type can be compared with a cheaper key type. Usually this key is part of the value_type.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a34b2c5bb332fc01aaa52656d0753f932"></a><span class="identifier">iterator_to</span><span class="special">(</span><span class="identifier">reference</span> value<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac25be409d71df349ee58594519513062"></a><span class="identifier">iterator_to</span><span class="special">(</span><span class="identifier">const_reference</span> value<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a4130c0956d71778f78644c0655fe416c"></a><span class="identifier">local_iterator_to</span><span class="special">(</span><span class="identifier">reference</span> value<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1aa47a4e6e5bb4d448a51cb845d8170142"></a><span class="identifier">local_iterator_to</span><span class="special">(</span><span class="identifier">const_reference</span> value<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2"></a><span class="identifier">bucket_count</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the number of buckets passed in the constructor or the last rehash function.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a5d14f3d85df0aa9b06d943545393702f"></a><span class="identifier">bucket_size</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: n is in the range [0, this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2">bucket_count()</a>).</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns the number of elements in the nth bucket.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a0e4385e4570b5dff4cdbede21b0a42ce"></a><span class="identifier">bucket</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> k<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> KeyType<span class="special">,</span> <span class="keyword">typename</span> KeyHasher<span class="special">&gt;</span> 
  <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a5fd970e31fed491f319d8b7020c52d83"></a><span class="identifier">bucket</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">KeyType</span> <span class="special">&amp;</span> k<span class="special">,</span> <span class="identifier">KeyHasher</span> hash_func<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: "hash_func" must be a hash function that induces the same hash values as the stored hasher. The difference is that "hash_func" hashes the given key instead of the value_type.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns the index of the bucket in which elements with keys equivalent to k would be found, if any such element existed.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: If hash_func throws.</p>
<p><span class="bold"><strong>Note</strong></span>: the return value is in the range [0, this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a9ff60254b007bb0c178257d5e97c0fa2">bucket_count()</a>).    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">bucket_ptr</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a1873fe24ccb8dd831111ac11594fa885"></a><span class="identifier">bucket_pointer</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the bucket array pointer passed in the constructor or the last rehash function.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="identifier">local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1acc350a5919b385994aa6784b773df166"></a><span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ac8967beebeabb7dd93ecc27a7c63aad7"></a><span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a855992523c55e74cd5691a377601bc5c"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a649a071731f6c9ee2dd385532edeef45"></a><span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ab90bc870d13993a9ac474c8d9ff9aa41"></a><span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="identifier">const_local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1afbea5b1c32cc39af657b9f96426a49c8"></a><span class="identifier">cend</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ab3004e31b8d79e51feea2453733f800e"></a><span class="identifier">rehash</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span> new_bucket_traits<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a3eb11ce917ff0940c5449ad498361dee"></a><span class="identifier">full_rehash</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Note</strong></span>: This function is used when keys from inserted elements are changed (e.g. a language change when key is a string) but uniqueness and hash properties are preserved so a fast full rehash recovers invariants for *this without extracting and reinserting all elements again.</p>
<p><span class="bold"><strong>Requires</strong></span>: Calls produced to the hash function should not alter the value uniqueness properties of already inserted elements. If hasher(key1) == hasher(key2) was true when elements were inserted, it shall be true during calls produced in the execution of this function.</p>
<p>key_equal is not called inside this function so it is assumed that key_equal(value1, value2) should produce the same results as before for inserted elements.</p>
<p><span class="bold"><strong>Effects</strong></span>: Reprocesses all values hold by *this, recalculating their hash values and redistributing them though the buckets.</p>
<p>If <a class="link" href="structboost_1_1intrusive_1_1store__hash.html" title="Struct template store_hash">store_hash</a> option is true, this method uses the hash function and updates the stored hash value.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Average case linear in this-&gt;<a class="link" href="classboost_1_1intrusive_1_1unordered__set.html#doxygen.classboost_1_1intrusive_1_1unordered__set_1a231f01811305390fb38ef92c1e3027de">size()</a>, worst case quadratic.</p>
<p><span class="bold"><strong>Throws</strong></span>: If the hasher functor throws. Basic guarantee.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1afc16c65b7eb9f1f0f11a146aeb2dcbe9"></a><span class="identifier">incremental_rehash</span><span class="special">(</span><span class="keyword">bool</span> grow <span class="special">=</span> <span class="keyword">true</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>:</p>
<p><span class="bold"><strong>Effects</strong></span>:</p>
<p><span class="bold"><strong>Complexity</strong></span>:</p>
<p><span class="bold"><strong>Throws</strong></span>:</p>
<p><span class="bold"><strong>Note</strong></span>: this method is only available if incremental&lt;true&gt; option is activated.    </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ae1470c48f8e5ce4f877c38e5485c96ac"></a><span class="identifier">incremental_rehash</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bucket_traits</span> <span class="special">&amp;</span> new_bucket_traits<span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a41482f21f938c099a358c0ae72afa114"></a><span class="identifier">split_count</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: incremental&lt;&gt; option must be set</p>
<p><span class="bold"><strong>Effects</strong></span>: returns the current split count</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing    </p>
</li>
</ol></div>
</div>
<div class="refsect2">
<a name="id-1.3.17.42.44.6.4.11"></a><h3>
<a name="id107-bb"></a><code class="computeroutput">unordered_set</code> public static functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem"><pre class="literallayout"><span class="keyword">static</span> <span class="identifier">local_iterator</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1af7f23fe913415154b1b07314705fa1d2"></a><span class="identifier">s_local_iterator_to</span><span class="special">(</span><span class="identifier">reference</span> value<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem"><pre class="literallayout"><span class="keyword">static</span> <span class="identifier">const_local_iterator</span> 
<a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1ad283c478c8f3952010e1a051ac137920"></a><span class="identifier">s_local_iterator_to</span><span class="special">(</span><span class="identifier">const_reference</span> value<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">static</span> <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a7709f06fa88c66b613d4917c296b7a85"></a><span class="identifier">suggested_upper_bucket_count</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the nearest new bucket count optimized for the container that is bigger or equal than n. This suggestion can be used to create bucket arrays with a size that will usually improve container's performance. If such value does not exist, the higher possible value is returned.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">static</span> <span class="identifier">size_type</span> <a name="doxygen.classboost_1_1intrusive_1_1unordered__set_1a5480cfcd11b6b40ac8aae19a5c7bd991"></a><span class="identifier">suggested_lower_bucket_count</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the nearest new bucket count optimized for the container that is smaller or equal than n. This suggestion can be used to create bucket arrays with a size that will usually improve container's performance. If such value does not exist, the lowest possible value is returned.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Amortized constant time.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.    </p>
</li>
</ol></div>
</div>
</div>
</div>
<div class="copyright-footer">Copyright © 2005 Olaf Krzikalla<br>Copyright © 2006-2015 Ion Gaztanaga<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="classboost_1_1intrusive_1_1unordered__multiset.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../intrusive/reference.html#doxygen.unordered__set_8hpp"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="structboost_1_1intrusive_1_1make__unordered__set__base__hook.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
